const searchDoc = {
  "component-format": [[
    "component format",
    "format",
    "component",
    "Component",
    "Component format",
    "Component Format",
  ], ["Components are the building blocks of Svelte applications. They are written into .svelte files, using a superset of HTML.  All three sections — script, styles and markup — are optional."]],
  "component-format-script": [[
    "component format script",
    "component script",
    "script",
    "script tag",
  ], ["A <script></script> block contains JavaScript that runs when a component instance is created. Variables declared (or imported) at the top level are 'visible' from the component's markup."]],
  "component-format-script-1-export-creates-a-component-prop": [["export", "exports"], ["The export keyword marks a variable declaration as a property or prop, which means it becomes accessible to consumers of the component. 'Export' syntax: export let foo;"]],
  "component-format-script-2-assignments-are-reactive": [["state", "update"], ["To change component state and trigger a re-render, assign to a locally declared variable. Svelte's reactivity is based on assignments. Use '$:' at the top-level."]],
  "component-format-script-3-$-marks-a-statement-as-reactive": [["$", "$:", "reactive"], ["Any top-level statement (i.e. not inside a block or a function) can be made reactive by prefixing it with the '$:'"]],
  "component-format-script-4-prefix-stores-with-$-to-access-their-values": [[], []],
  "component-format-script-context-module": [[
    "context module",
    "module",
    "context",
    "component format context module",
    "component format script context module",
  ], ["A <script> tag with  context='module' attribute runs once when the module first evaluates, rather than for each component instance. Values declared in this block are accessible from a regular <script> but not vice versa."]],
  "component-format-style": [["component format style", "format style", "style", "<style>", "style tag"], ["CSS inside a <style> block will be scoped to that component: \n <style> \n p {color: burlywood;}\n </style>"]],
  "template-syntax": ["template syntax", "template", "syntax"],
  "template-syntax-tags": [[
    "template syntax tags",
    "tags",
    "template tags",
    "tag",
  ], ["A lowercase tag denotes a regular HTML element. A capitalised tag indicates a component."]],
  "template-syntax-attributes-and-props": [[
    "attritbutes and props",
    "attributes",
    "props",
    "attributes syntax",
    "props syntax",
  ], ["Attributes work exactly like their HTML counterparts. Values may be unquoted, contain JavaScript expressions, or they can be JavaScript expressions."]],
  "template-syntax-text-expressions": [[
    "text expressions",
    "template syntax text expressions",
    "text expression",
    "text expression syntax",
  ], ["Text can also contain JavaScript expressions: {expression}"]],
  "template-syntax-comments": [[
    "comments",
    "comments syntax",
    "comment syntax",
    "comment",
  ], ["Comments beginning with 'svelte-ignore' disable warnings for the next block of markup. Comment syntax: <!-- this is a comment! -->"]],
  "template-syntax-if": [[
    "{if}",
    "{@if...}",
    "{@if}",
    "{if",
    "if",
    "{#if...",
    "{#if",
    "if syntax",
    "{#if syntax",
    "{if syntax",
  ], ["Content that is conditionally rendered can be wrapped in an if block. 'If' syntax: {#if expression}...{:else if expression}...{/if}"]],
  "template-syntax-each": [[
    "{each}",
    "{@each...}",
    "{@each}",
    "{each",
    "each",
    "{#each...",
    "{#each",
    "each syntax",
    "{#each syntax",
    "{each syntax",
  ], ["Iterating over lists of values can be done with an each block. 'Each' syntax: {#each items as item}	<li> {item.name} x {item.qty} </li> {/each} "]],
  "template-syntax-await": [[
    "{await}",
    "{@await...}",
    "{@await}",
    "{await",
    "await",
    "{#await...",
    "{#await",
    "await syntax",
    "{#await syntax",
    "{await syntax",
  ], ["Await blocks allow you to branch on the three possible states of a Promise — pending, fulfilled or rejected. 'Await' syntax: {#await expression}...{:then name}...{:catch name}...{/await}"]],
  "template-syntax-key": [[
    "{key}",
    "{@key...}",
    "{@key}",
    "{key",
    "key",
    "{#key...",
    "{#key",
    "key syntax",
    "{#key syntax",
    "{key syntax",
  ], ["Key blocks destroy and recreate their contents when the value of an expression changes."]],
  "template-syntax-html": [[
    "{html}",
    "{@html...}",
    "{@html}",
    "{html",
    "html",
    "{@html...",
    "{@html",
    "html syntax",
    "{@html syntax",
    "{html syntax",
  ], ["In a text expression, characters like < and > are escaped; however, with HTML expressions, they're not. 'html' syntax: <div class='blog-post'> {@html post.content} </div>"]],
  "template-syntax-debug": [[
    "{debug}",
    "{@debug...}",
    "{@debug}",
    "{debug",
    "debug",
    "{@debug...",
    "{@debug",
    "debug syntax",
    "{@debug syntax",
    "{debug syntax",
  ], ["The {@debug ...} tag offers an alternative to console.log(...). It logs the values of specific variables whenever they change. 'Debug' syntax: {@debug var1, var2, ..., varN}"]],
  "template-syntax-const": [[
    "{const}",
    "{@const...}",
    "{@const}",
    "{const",
    "const",
    "{@const...",
    "{@const",
    "const syntax",
    "{@const syntax",
    "{const syntax",
  ], ["{@const ...} defines a local constant. {@const} is only allowed as direct child of {#if}, {:else if}, {:else}, {#each}, {:then}, {:catch}, <Component /> or <svelte:fragment />."]],
  "template-syntax-element-directives": [[
    "element directives",
    "directives",
  ], ["Elements can have directives, which control the element's behaviour in some way."]],
  "template-syntax-element-directives-on-eventname": [[
    "on eventname",
    "element on eventname",
    "on click",
    "on",
    "event",
    "events",
  ], ["Use the on: directive to listen to DOM events. Add modifiers to DOM events with the | character. 'On' syntax: on:eventname | modifier = {handler}"]],
  "template-syntax-element-directives-bind-property": [[
    "bind",
    "bind property",
    "binding",
    "bind syntax",
  ], ["The bind: directive allows data to flow from child to parent. 'Bind' syntax: <textarea bind:value={text}></textarea>"]],
  "template-syntax-element-directives-bind-group": [["bind group"], ["Inputs that work together can use bind:group. 'Bind group' syntax: bind:group={variable}"]],
  "template-syntax-element-directives-bind-this": [[
    "bind this",
    "this element",
  ], ["Use bind:this to get a reference to a DOM node. 'Bind this' syntax: bind:this={dom_node}"]],

  "template-syntax-element-directives-class-name": [[
    "class name",
    "class",
    "element class",
    "class element"
  ], ["A class: directive provides a shorter way of toggling a class on an element. 'Class' syntax: class:name={value}"]],
  "template-syntax-element-directives-style-property": [[
    "style property",
    "element directives style property",
  ], ["The style: directive provides a shorthand for setting multiple styles on an element. Style: directives take precedent over style attributes. 'Style' syntax: style:property='value'"]],
  "template-syntax-element-directives-use-action": [["use action", "action"], ["Actions are functions that are called when an element is created. 'Action' syntax: use:action | use:action={parameters}"]],
  "template-syntax-element-directives-transition-fn": [[
    "transition fn",
    "transition",
    "transition:fn",
    "transition function",
  ], ["A transition is triggered by an element entering or leaving the DOM as a result of a state change. 'Transition' syntax: transition:fn | transition:fn={parameters}"]],
  "template-syntax-element-directives-in-fn-out-fn": [[
    "in function out function",
    "in:fn out:fn",
    "in fn",
    "out fn",
  ], ["Similar to transition:, but only applies to elements entering (in:) or leaving (out:) the DOM. Unlike with transition:, transitions applied with in: and out: are not bidirectional"]],
  "template-syntax-element-directives-animate-fn": [[
    "animate fn",
    "animate",
    "animate:fn",
  ], ["An animation is triggered when the contents of a keyed each block are re-ordered. Animations do not run when an element is added or removed. 'Animate' syntax: animate:name"]],
  "template-syntax-component-directives": [["component directives"], []],
  "template-syntax-component-directives-on-eventname": [[
    "component on eventname",
  ], ["Components can emit events using createEventDispatcher, or by forwarding DOM events. Listening for component events looks the same as listening for DOM events. 'Component event' syntax:  <SomeComponent on:whatever={handler}/>"]],
  "template-syntax-component-directives---style-props": [[
    "style props",
    "component directives style props",
    "component directives style",
    "--style-props",
    "style-props"
  ], ["Styles can be passed as props to components. Svelte's implementation is syntactic sugar for adding a wrapper element. 'Style props' syntax: <div style=' --rail-color: black; --track-color: rgb(0, 0, 255)'> <Component/> </div>" ]],
  "template-syntax-component-directives-bind-property": [["bind property"], ["You can bind to component props using the same syntax as for elements. 'Bind property' syntax: bind:property={variable}"]],
  "template-syntax-component-directives-bind-this": [["bind this"], ["Components support bind:this, which allows you to interact with component instances programmatically. 'Bind this' syntax: bind:this={component_instance}"]],
  "template-syntax-slot": [["slot", "slot syntax", "slots"], ["Components can have child content which is exposed in the child component using the <slot> element. 'Slot' syntax: <slot><!-- optional fallback content --></slot>"]],
  "template-syntax-slot-slot-name-name": [["slot name", "slot names"], ["Named slots allow consumers to target specific areas."]],
  "template-syntax-slot-$$slots": [["$$slots", "$$Slots", "$$slot", "$$Slot"], ["$$slots is an object whose keys are the names of the slots passed into the component by the parent. If the parent does not pass in a slot with a particular name, that name will not be present in $$slots. "]],
  "template-syntax-slot-slot-key-value": [[
    "slot key value",
    "slot key",
    "slot value",
  ], ["Slots can pass values back to the parent using props. The parent exposes the values to the slot template using the let: directive."]],
  "template-syntax-svelte-self": [[
    "self",
    "<svelte self>",
    "svelte self",
    "<svelte:self>",
    "svelte:self",
  ], ["The <svelte:self> element allows a component to include itself, recursively. It cannot appear at the top level of your markup; it must be inside an if or each block or passed to a component's slot"]],
  "template-syntax-svelte-component": [[
    "<svelte component>",
    "svelte component",
    "<svelte:component>",
    "svelte:component",
  ], ["The <svelte:component> element renders a component dynamically. When the property changes, the component is destroyed and recreated. 'Svelte component' syntax: <svelte:component this={expression}/>"]],
  "template-syntax-svelte-element": [[
    "<svelte element>",
    "svelte element",
    "<svelte:element>",
    "svelte:element",
  ], ["The <svelte:element> element lets you render an element of a dynamically specified type.Any properties and event listeners present will be applied to the element."]],
  "template-syntax-svelte-window": [[
    "<svelte window>",
    "svelte window",
    "<svelte:window>",
    "svelte:window",
  ], ["The <svelte:window> element allows you to add event listeners to the window object without having to removing them when the component is destroyed. Unlike <svelte:self>, this element may only appear the top level of your component"]],
  "template-syntax-svelte-body": [[
    "<svelte body>",
    "svelte body",
    "<svelte:body>",
    "svelte:body",
    ":body",
    "body"
  ], ["Like <svelte:window>, this element adds listeners to events on document.body which don't fire on window. It also allows actions on the <body> element. 'Svelte window' syntax: <svelte:body on:mouseenter={handleMouseenter} use:someAction/>"]],
  "template-syntax-svelte-head": [[
    "<svelte head>",
    "svelte head",
    "<svelte:head>",
    "svelte:head",
  ], ["This makes it possible to insert elements into document.head. As with <svelte:window> and <svelte:body>, it may only appear at the top level of your component. 'Svelte head' syntax: <svelte:head>...</svelte:head>"]],

  "template-syntax-svelte-options": [[
    "<svelte options>",
    "svelte options",
    "<svelte:options>",
    "svelte:options",
  ], ["This provides a place to specify per-component compiler options, which are detailed in the compiler section. 'Svelte options' syntax: <svelte:options option={value}/>"]],

  "template-syntax-svelte-fragment": [[
    "<svelte fragment>",
    "svelte fragment",
    "<svelte:fragment>",
    "svelte:fragment",
  ], ["The <svelte:fragment> element allows you to place content in a named slot without wrapping it in a container DOM element. This keeps the flow layout of your document intact."]],
  "run-time": [["run time", "run-time"], []],
  "run-time-svelte": [["svelte run time", "run time svelte"], []],
  "run-time-svelte-onmount": [["onMount", "on mount", "onmount"], ["onMount schedules a callback to run as soon as the component has been mounted to the DOM. If onMount returns a function, it will be called when the component is unmounted.'onMount' syntax : onMount(callback: () => void)"]],
  "run-time-svelte-beforeupdate": [[
    "beforeupdate",
    "before update",
    "beforeUpdate",
  ], ["beforeUpdate schedules a callback to run immediately before the component is updated after any state change. 'beforeUpdate' syntax: beforeUpdate(callback: () => void)"]],

  "run-time-svelte-afterupdate": [[
    "afterupdate",
    "after update",
    "afterUpdate",
  ], ["afterUpdate schedules a callback to run immediately after the component has been updated. 'afterUpdat' syntax: afterUpdate(callback: () => void)"]],
  "run-time-svelte-ondestroy": [["onDestroy", "on destroy", "ondestroy"], ["onDestroy schedules a callback to run immediately before the component is unmounted. 'onDestroy' syntax: onDestroy(callback: () => void)"]],
  "run-time-svelte-tick": [["tick", "svelte tick"], ["Returns a promise that resolves once any pending state changes have been applied, or in the next microtask if there are none. 'tick' syntax: promise: Promise = tick()"]],
  "run-time-svelte-setcontext": [["set context", "setcontext", "setContext"], ["Associates an arbitrary context object with the current component and the specified key and returns that object. The context is then available to children of the component with getContext. 'setContext' syntax: setContext(key: any, context: any)"]],
  "run-time-svelte-getcontext": [["get context", "getcontext", "getContext"], ["Retrieves the context that belongs to the closest parent component with the specified key. Must be called during component initialisation. 'getContext' syntax: context: any = getContext(key: any)"]],
  "run-time-svelte-hascontext": [["has context", "hascontext", "hasContext"], ["Checks whether a given key has been set in the context of a parent component. Must be called during component initialisation. 'hasContext' syntax: hasContext: boolean = hasContext(key: any)"]],
  "run-time-svelte-getallcontexts": [[
    "get all contexts",
    "get all context",
    "getallcontext",
    "getallcontexts",
  ], ["Retrieves the whole context map that belongs to the closest parent component. Must be called during component initialisation.'getAllContexts' syntax: contexts: Map<any, any> = getAllContexts()"]],

  "run-time-svelte-createeventdispatcher": [[
    "create event dispatcher",
    "event dispatcher",
    "create dispatcher",
  ], []],
  "run-time-svelte-store": [["store", "svelte store"], []],
  "run-time-svelte-store-writable": [[
    "writable",
    "store writable",
    "svelte store writable",
  ], []],
  "run-time-svelte-store-readable": [[
    "readable",
    "store readable",
    "svelte store readable",
  ], []],
  "run-time-svelte-store-derived": [[
    "derived",
    "store derived",
    "svelte store derived",
  ], []],
  "run-time-svelte-store-get": [["store get", "get store", "svelte store get"], []],
  "run-time-svelte-motion": [["svelte motion", "run time motion", "motion"], []],
  "run-time-svelte-motion-tweened": [[
    "svelte motion tweened",
    "run time tweened",
    "tweened",
    "motion tweened",
  ], []],
  "run-time-svelte-motion-spring": [[
    "svelte motion spring",
    "run time spring",
    "spring",
    "motion spring",
  ], []],
  "run-time-svelte-transition": [[
    "run time transition",
    "transition",
    "svelte transition",
  ], ["The svelte/transition module exports seven functions: fade, blur, fly, slide, scale, draw and crossfade. They are for use with Svelte transitions."]],

  "run-time-svelte-transition-fade": [[
    "fade transition",
    "transition fade",
    "run time fade",
    "fade",
  ], []],
  "run-time-svelte-transition-blur": [[
    "blur transition",
    "blur fade",
    "run time blur",
    "blur",
  ], []],
  "run-time-svelte-transition-fly": [[
    "fly transition",
    "fly fade",
    "run time fly",
    "fly",
  ], []],
  "run-time-svelte-transition-slide": [[
    "slide transition",
    "transition slide",
    "run time slide",
    "slide",
  ], []],
  "run-time-svelte-transition-scale": [[
    "scale transition",
    "scale fade",
    "run time scale",
    "scale",
  ], []],
  "run-time-svelte-transition-draw": [[
    "draw transition",
    "transition draw",
    "run time draw",
    "draw",
  ], []],
  "run-time-svelte-transition-crossfade": [[
    "crossfade transition",
    "transition crossfade",
    "run time crossfade",
    "crossfade",
  ], []],
  "run-time-svelte-animate": [[
    "animate",
    "run time animate",
    "svelte animate",
    "run time svelte animate",
  ], ["The svelte/animate module exports one function for use with Svelte animations. 'Animate' syntax: animate:flip={params}"]],

  "run-time-svelte-animate-flip": [[
    "animate flip",
    "run time animate flip",
    "svelte animate flip",
    "run time svelte animate flip",
    "flip",
  ], []],

  "run-time-svelte-easing": [["easing", "run time easing", "svelte easing"], ["Easing functions specify the rate of change over time and are useful when working with Svelte's built-in transitions and animations as well as the tweened and spring utilities."]],
  "run-time-svelte-register": [["register", "run time register", "svelte register"], ["To render Svelte components in Node.js without bundling, use require('svelte/register'). After that, you can use require to include any .svelte file."]],
  "run-time-client-side-component-api": [["component api", "api", "client side api", "client side", "client side component", "client side component api"], ["A client-side component — that is, a component compiled with generate: 'dom' (or the generate option left unspecified) is a JavaScript class."]],
  "run-time-client-side-component-api-creating-a-component": [["create api component", "api component", "creating api component", "creating an api component"], []],
  "run-time-client-side-component-api-$set": [["$set", "api $set"], ["Programmatically sets props on an instance. component.$set({ x: 1 }) is equivalent to x = 1 inside the component's <script> block. '$set' syntax: component.$set(props)"]],
  "run-time-client-side-component-api-$on": [["$on", "api $on"], ["Causes the callback function to be called whenever the component dispatches an event. A function is returned that will remove the event listener when called. '$on' syntax: component.$on(event, callback)"]],
  "run-time-client-side-component-api-$destroy": [["$destroy", "api $destroy"], ["Removes a component from the DOM and triggers any onDestroy handlers. '$destroy' syntax: component.$destroy()"]],
  "run-time-client-side-component-api-component-props": [["api component props", "api props"], []],
  "run-time-custom-element-api": [["custom element", "custom element api"], []],
  "run-time-server-side-component-api": [["server side", "server side api", "server-side api"], []],
  "compile-time": [["compile time", "compile"], ["The bundler plugin that the Svelte team most recommends and invests in is vite-plugin-svelte. "]],
  "compile-time-svelte-compile": [["svelte compile"], []],
  "compile-time-svelte-parse": [["svelte parse", "parse"], []],
  "compile-time-svelte-preprocess": [["svelte preprocess", "preprocess"], []],
  "compile-time-svelte-walk": [["svelte walk", "walk"], []],
  "compile-time-svelte-version": [["version", "svelte version"], []]
};
  export default searchDoc